﻿#define _CRT_SECURE_NO_WARNINGS

//构造函数
//#include<iostream>
//using namespace std;
//class Data
//{
//public:
//	//无参构造函数
//	/*Data()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}*/
//	//带参构造函数
//	/*Data(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}*/
//	//全缺省构造函数
//	Data(int year = 2, int month = 2, int day = 2)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//
//};
//
//int main()
//{
//	/*Data d1;
//	d1.Print();*/
//
//	/*Data d2(2025, 4, 20);
//	d2.Print();*/
//
//	Data d3(2024);
//	d3.Print();
//}


//析构函数
//#include<iostream>
//using namespace std;
//typedef int STDataType;
//class Stack
//{
//public:
//    Stack(int n = 4)
//    {
//        _a = (STDataType*)malloc(sizeof(STDataType) * n);
//        if (nullptr == _a)
//        {
//            perror("malloc申请空间失败");
//                return;
//        }
//        _capacity = n;
//        _top = 0;
//    }
//    ~Stack()
//    {
//        cout << "~Stack()" << endl;
//        free(_a);
//        _a = nullptr;
//        _top = _capacity = 0;
//    }
//private:
//    STDataType* _a;
//    size_t _capacity;
//    size_t _top;
//};
//// 两个Stack实现队列
//
//class MyQueue
//{
//public:
//    //编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
//    // 显⽰写析构，也会⾃动调⽤Stack的析构
//    /*~MyQueue()
//        {}*/
//private:
//    Stack pushst;
//    Stack popst;
//};
//int main()
//{
//    Stack st;
//    MyQueue mq;
//    return 0;
//}


//c++和c语言实现栈对比
//c
//#include<stdio.h>
//#include<stdlib.h>
//#include<stdbool.h>
//#include<assert.h>
//
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType* a;
//	int top;
//	int capacity;
//}ST;
//void STInit(ST* ps)
//{
//	assert(ps);
//	ps->a = NULL;
//	ps->top = ps->capacity = 0;
//}
//void STDestroy(ST* ps)
//{
//	assert(ps);
//	free(ps->a);
//	ps->a = NULL;
//	ps->top = ps->capacity = 0;
//}
//void STPush(ST* ps, STDataType x)
//{
//	assert(ps);
//	if (ps->top == ps->capacity)
//	{
//		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
//		int* tmp = (int*)realloc(ps->a, sizeof(STDataType) * newcapacity);
//		if (tmp == NULL)
//		{
//			perror("realloc fail");
//			return;
//		}
//		ps->a = tmp;
//		ps->capacity = newcapacity;
//	}
//	ps->a[ps->top] = x;
//	ps->top++;
//}
//bool STEmpty(ST* ps)
//{
//	assert(ps);
//	return ps->top == 0;
//}
//void STPop(ST* ps)
//{
//	assert(ps);
//	assert(!STEmpty(ps));
//	ps->top--;
//}
//STDataType STTop(ST* ps)
//{
//	assert(ps);
//	assert(!STEmpty(ps));
//	return ps->a[ps->top - 1];
//}
//int STSize(ST* ps)
//{
//	assert(ps);
//	return ps->top;
//}
//int main()
//{
//	ST s;
//	STInit(&s);
//	STPush(&s, 1);
//	STPush(&s, 2);
//	STPush(&s, 3);
//	STPush(&s, 4);
//	while (!STEmpty(&s))
//	{
//		printf("%d\n", STTop(&s));
//		STPop(&s);
//	}
//	STDestroy(&s);
//	return 0;
//}

//c++
#include<iostream>
#include<assert.h>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	void Init(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
				return;
		}
		_capacity = n;
		_top = 0;
	}
	void push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	void pop()
	{
		assert(_top > 0);
		_top--;
	}
	bool Empty()
	{
		return _top == 0;
	}
	int Top()
	{
		assert(_top > 0);
		
		return _a[_top - 1];
		
	}
	void Destroy()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack s;
	s.Init();
	s.push(1);
	s.push(2);
	s.push(3);
	s.push(4);
	while (!s.Empty())
	{
		printf("%d ", s.Top());
		s.pop();
	}
	s.Destroy();
	return 0;
}